home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / include / rpc.h < prev    next >
C/C++ Source or Header  |  1992-10-02  |  8KB  |  190 lines
  1. /*
  2.  * rpc.h --
  3.  *
  4.  *    User declarations for dealing with the Sprite RPC system.
  5.  *
  6.  * Copyright (C) 1987 Regents of the University of California
  7.  * All rights reserved.
  8.  *
  9.  *
  10.  * $Header: /sprite/src/lib/include/RCS/rpc.h,v 1.8 91/05/30 13:12:56 jhh Exp Locker: jhh $ SPRITE (Berkeley)
  11.  */
  12.  
  13. #ifndef _RPCUSER
  14. #define _RPCUSER
  15.  
  16. #include <cfuncproto.h>
  17. #include <sprite.h>
  18. #include <spriteTime.h>
  19.  
  20. /* 
  21.  * All RPC names should fit in a char array this long (including the 
  22.  * trailing null byte).
  23.  */
  24. #define RPC_MAX_NAME_LENGTH    100
  25.  
  26.  
  27. /*
  28.  * The record counting various RPC client system events.
  29.  */
  30. typedef struct Rpc_CltStat {
  31.         /*
  32.          * Counters incremented during dispatch.
  33.          */
  34.     int toClient;    /* # of packets destined for client side RPC */
  35.     int badChannel;    /* # of packets discarded because of a bad channel */
  36.             /* (toClient - badChannel) msgs passed to dispatch */
  37.     int chanBusy;    /* # of times input was dropped because the channel
  38.              *     it was for was busy, ie. not waiting for input */
  39.     int badId;        /* # of packets discarded because of a bad (old) ID */
  40.         /*
  41.          * requests = replies + aborts
  42.          */
  43.     int requests;    /* # of request messages sent to the server */
  44.     int replies;    /* ... of replies from the server.  Not counting
  45.              *     on going RPCs, the total # of requests should
  46.              *     equal the sum of timeouts, tooManyAcks, errors
  47.              *     and replies. */
  48.     int acks;        /* # of acknowledgment received from the server */
  49.     int recvPartial;    /* # of partial acks received from the server */
  50.     int    nacks;        /* # of negative acknowledgements from the server */
  51.     int    reNacks;    /* # of nacks after first for requests */
  52.     int    maxNacks;    /* # of nacks after setting max backoff wait */
  53.         /*
  54.          * timeouts = resends + aborts + sentPartial
  55.          */
  56.     int timeouts;    /* # of timeouts waiting for a reply message */
  57.     int aborts;        /* # of times an RPC aborted because of timeouts */
  58.     int resends;    /* # of messages resent to the server */
  59.     int sentPartial;    /* # of partial acks sent to the server */
  60.  
  61.     int errors;        /* ... of errors received from the server, these
  62.              *     errors are reflections of errors during
  63.              *     execution of the RPC, or errors during dispatch
  64.              *     of the RPC on the server. */
  65.     int nullErrors;    /* ... of times return error code was null */
  66.     int dupFrag;    /* # of duplicate frags received */
  67.     int close;        /* # of close requests from the server */
  68.  
  69.     int oldInputs;    /* Same as badID, but when recieved by process */
  70.     int badInput;    /* # times received unexpected message type */
  71.     int tooManyAcks;    /* # of times a large number of acks were
  72.              * received while waiting for a reply. Could be
  73.              * incremented more than once per RPC */
  74.         /*
  75.          * These fields record events related to allocating channels 
  76.          */
  77.     int chanWaits;    /* ... of times a process had to wait for a channel. */
  78.     int chanBroads;    /* ... of times a broadcast was done to wake up
  79.              *     processes waiting for channels. */
  80.     int chanHits;    /* ... of times a channel was reallocated to the same
  81.              *     server. */
  82.     int chanNew;    /* ... indicates how many different channels have been
  83.              *     allocated.  The system tries to allocate a
  84.              *     different channel for different servers.*/
  85.     int chanReuse;    /* ... of times a channel had to allocated for a
  86.              *     server that was different from the one it had
  87.              *     been allocated to before. */
  88.     int    newTrouble;    /* ... of times a server not already ramped down
  89.                    is ramped down by client. */
  90.     int    moreTrouble;    /* ... of times a server already ramped down is again
  91.                    noted as sending nacks. */
  92.     int    endTrouble;    /* ... of times a server previously ramped down is
  93.                    marked as okay again. */
  94.     int    noMark;        /* ... of times there was no room to mark a server
  95.                    as in trouble - too many servers in trouble! */
  96.     int    nackChanWait;    /* ... of waits for busy channel 'cause ramped down. */
  97.         /*
  98.          * These are common to both client-side and server-side
  99.          */
  100.     int paramOverrun;    /* ... of times the parameters were too big */
  101.     int dataOverrun;    /* ... of times the data was too big */
  102.     int shorts;        /* ... of too short packets discarded by Rpc_Dispatch */
  103.     int longs;        /* ... of too long packets trimmed down, Rpc_Dispatch */
  104.  
  105. } Rpc_CltStat;
  106.  
  107. /*
  108.  * The record counting various RPC server system events.
  109.  * 
  110.  * Warning: the kernel routine RpcResetSrvStat relies on the fact that 
  111.  * the stats are an array of ints.
  112.  */
  113. typedef struct Rpc_SrvStat {
  114.     int toServer;    /* # messages to the server half of RPC */
  115.     int noAlloc;    /* # srvr msgs discarded due to no srvr proc avail */
  116.     int    nacks;        /* # neg acks sent */
  117.     int invClient;    /* # srvr msgs discarded from invalid clients */
  118.     int serverBusy;    /* # requests ignored because srvr proc was busy */
  119.             /* Messages passed to RpcServerDispatch is equal to
  120.              * toServer - noAlloc - invClient */
  121.     int requests;    /* # messages that start a new RPC */
  122.     int impAcks;    /* # requests that imp acked previous reply */
  123.     int handoffs;    /* # times complete message handed to srvr proc */
  124.     int fragMsgs;    /* # of packets that were the first fragment of msg */
  125.             /* requests = handoffs + fragMsgs - serverBusy */
  126.     int handoffAcks;    /* # acks sent when handoff occurred */
  127.     int fragAcks;    /* # acks sent when fragment received */
  128.     int sentPartial;    /* # of partial acknowledgments sent */
  129.     int busyAcks;    /* # acks sent when srvr proc was busy with request */
  130.  
  131.     int resends;    /* # of reply messages that were resent */
  132.     int badState;    /* # msgs ignored because srvr in unexpected state */
  133.     int extra;        /* # msgs ignored because srvr was SRV_FREE */
  134.     int reclaims;    /* # times a server process was forcibly reclaimed
  135.              *     from an unreachable client */
  136.     int reassembly;    /* # of packets that were reassembled */
  137.             /* Total number of fragments received is the sum of
  138.              * fragMsgs + dupFrag + reassembly */
  139.     int dupFrag;    /* # duplicate fragments received */
  140.     int nonFrag;    /* # nonFrag msgs ignored when srvr was SRV_FRAGMENT */
  141.     int fragAborts;    /* # requests that aborted previous frag assembly */
  142.  
  143.     int recvPartial;    /* # of partial acks received */
  144.     int closeAcks;    /* # acks that close a connection, RPC_CLOSE */
  145.     int discards;    /* # broadcasts discarded because of SRV_NO_REPLY */
  146.     int unknownAcks;    /* # of unexpected types of acks */
  147.     int mostNackBuffers;/* high-water mark of nack buffers used */
  148.     int selfNacks;    /* # of nacks we tried to send ourselves */
  149. } Rpc_SrvStat;
  150.  
  151.  
  152. /*
  153.  * Commands for the Test_Rpc system call.
  154.  *    This is invoked via
  155.  *        status = Test_Rpc(command, argPtr);
  156.  */
  157.  
  158. #define TEST_RPC_ECHO    1
  159. #define TEST_RPC_SEND    2
  160. #define TEST_RPC_BOUNCE    3
  161.  
  162. typedef struct Rpc_EchoArgs {
  163.     int serverID;        /* Sprite host ID of echo target */
  164.     int n;            /* Number of repetitions */
  165.     int size;            /* Size of packet, up to 16 K bytes */
  166.     Address inDataPtr;        /* Pointer to send buffer */
  167.     Address outDataPtr;        /* Pointer to receive buffer */
  168.     Time *deltaTimePtr;        /* Elapsed time of all n tests */
  169. } Rpc_EchoArgs;
  170.  
  171. #define TEST_RPC_MAX_SERVERS    16
  172.  
  173. #define TEST_RPC_ECHO_ASYNC     4
  174. #define TEST_RPC_SEND_ASYNC     5
  175. #define TEST_RPC_RECEIVE_ASYNC    6
  176.  
  177. typedef struct Rpc_EchoAsyncArgs {
  178.     int        numServers;    /* Number of servers to use. */
  179.     int        servers[TEST_RPC_MAX_SERVERS];    /* Servers. */
  180.     int        n;        /* Number of repetitions. */
  181.     int        size;        /* Size of packet, up to 16 K bytes */
  182.     Address     inDataPtr;    /* Pointer to send buffer */
  183.     Address     outDataPtr;    /* Pointer to receive buffer */
  184.     Time     *deltaTimePtr;    /* Elapsed time of all n tests */
  185. } Rpc_EchoAsyncArgs;
  186.  
  187. extern void Rpc_GetName _ARGS_ ((int rpcNum, int resultLen, char *resultPtr));
  188.  
  189. #endif /* _RPCUSER */
  190.